home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / AIncludes / Memory.a < prev    next >
Encoding:
Text File  |  1996-01-24  |  22.3 KB  |  1,272 lines  |  [TEXT/MPS ]
  1. ;
  2. ;    File:        Memory.a
  3. ;
  4. ;    Contains:    Memory Manager Interfaces.
  5. ;
  6. ;    Version:    Technology:    System 7.5
  7. ;                Package:    Universal Interfaces 2.2 in “MPW” on ETO #20
  8. ;
  9. ;    Copyright:    © 1984-1995 by Apple Computer, Inc.
  10. ;                All rights reserved.
  11. ;
  12. ;    Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13. ;                stack.  Include the file and version information (from above)
  14. ;                in the problem description and send to:
  15. ;                    Internet:    apple.bugs@applelink.apple.com
  16. ;                    AppleLink:    APPLE.BUGS
  17. ;
  18. ;
  19.  
  20.     IF &TYPE('__MEMORY__') = 'UNDEFINED' THEN
  21. __MEMORY__ SET 1
  22.  
  23.  
  24.     IF &TYPE('__TYPES__') = 'UNDEFINED' THEN
  25.     include 'Types.a'
  26.     ENDIF
  27. ;        include 'ConditionalMacros.a'                                ;
  28.  
  29.     IF &TYPE('__MIXEDMODE__') = 'UNDEFINED' THEN
  30.     include 'MixedMode.a'
  31.     ENDIF
  32.  
  33. maxSize                            EQU        $800000                ;Max data block size is 8 megabytes
  34. defaultPhysicalEntryCount        EQU        8
  35. ; values returned from the GetPageState function 
  36. kPageInMemory                    EQU        0
  37. kPageOnDisk                        EQU        1
  38. kNotPaged                        EQU        2
  39.  
  40. ; masks for Zone->heapType field 
  41. k32BitHeap                        EQU        1                    ; valid in all Memory Managers 
  42. kNewStyleHeap                    EQU        2                    ; true if new Heap Manager is present 
  43. kNewDebugHeap                    EQU        4                    ; true if new Heap Manager is running in debug mode on this heap 
  44.  
  45. ; size of a block in bytes 
  46. ; typedef long                 Size
  47. ; typedef struct Zone         Zone, *THz
  48. Zone                     RECORD    0
  49. bkLim                     ds.l   1        ; offset: $0 (0)
  50. purgePtr                 ds.l   1        ; offset: $4 (4)
  51. hFstFree                 ds.l   1        ; offset: $8 (8)
  52. zcbFree                     ds.l   1        ; offset: $C (12)
  53. gzProc                     ds.l   1        ; offset: $10 (16)
  54. moreMast                 ds.w   1        ; offset: $14 (20)
  55. flags                     ds.w   1        ; offset: $16 (22)
  56. cntRel                     ds.w   1        ; offset: $18 (24)
  57. maxRel                     ds.w   1        ; offset: $1A (26)
  58. cntNRel                     ds.w   1        ; offset: $1C (28)
  59. heapType                 ds.b   1        ; offset: $1E (30)
  60. unused                     ds.b   1        ; offset: $1F (31)
  61. cntEmpty                 ds.w   1        ; offset: $20 (32)
  62. cntHandles                 ds.w   1        ; offset: $22 (34)
  63. minCBFree                 ds.l   1        ; offset: $24 (36)
  64. purgeProc                 ds.l   1        ; offset: $28 (40)
  65. sparePtr                 ds.l   1        ; offset: $2C (44)
  66. allocPtr                 ds.l   1        ; offset: $30 (48)
  67. heapData                 ds.w   1        ; offset: $34 (52)
  68. sizeof                     EQU *            ; size:   $36 (54)
  69.                         ENDR
  70.  
  71. MemoryBlock             RECORD    0
  72. address                     ds.l   1        ; offset: $0 (0)
  73. count                     ds.l   1        ; offset: $4 (4)
  74. sizeof                     EQU *            ; size:   $8 (8)
  75.                         ENDR
  76.  
  77. ; typedef struct MemoryBlock  MemoryBlock
  78. LogicalToPhysicalTable     RECORD    0
  79. logical                     ds     MemoryBlock ; offset: $0 (0)
  80. physical                 ds.b   8 * MemoryBlock.sizeof ; offset: $8 (8)
  81. sizeof                     EQU *            ; size:   $48 (72)
  82.                         ENDR
  83.  
  84. ; typedef struct LogicalToPhysicalTable  LogicalToPhysicalTable
  85. ; typedef short             PageState
  86. ; typedef short             StatusRegisterContents
  87. ;
  88. ; pascal Ptr GetApplLimit(void)
  89. ;
  90.     IF ¬ GENERATINGCFM THEN
  91.         Macro
  92.         _GetApplLimit         &dest=(sp)
  93.         move.l               $0130,&dest
  94.         EndM
  95.     ELSE
  96.         IMPORT_CFM_FUNCTION    GetApplLimit
  97.     ENDIF
  98.  
  99. ;
  100. ; pascal THz SystemZone(void)
  101. ;
  102.     IF ¬ GENERATINGCFM THEN
  103.         Macro
  104.         _SystemZone         &dest=(sp)
  105.         move.l               $02A6,&dest
  106.         EndM
  107.     ELSE
  108.         IMPORT_CFM_FUNCTION    SystemZone
  109.     ENDIF
  110.  
  111. ;
  112. ; pascal THz ApplicationZone(void)
  113. ;
  114.     IF ¬ GENERATINGCFM THEN
  115.         Macro
  116.         _ApplicationZone         &dest=(sp)
  117.         move.l               $02AA,&dest
  118.         EndM
  119.     ELSE
  120.         IMPORT_CFM_FUNCTION    ApplicationZone
  121.     ENDIF
  122.  
  123. ;
  124. ; pascal Handle GZSaveHnd(void)
  125. ;
  126.     IF ¬ GENERATINGCFM THEN
  127.         Macro
  128.         _GZSaveHnd         &dest=(sp)
  129.         move.l               $0328,&dest
  130.         EndM
  131.     ELSE
  132.         IMPORT_CFM_FUNCTION    GZSaveHnd
  133.     ENDIF
  134.  
  135. ;
  136. ; pascal Ptr TopMem(void)
  137. ;
  138.     IF ¬ GENERATINGCFM THEN
  139.         Macro
  140.         _TopMem         &dest=(sp)
  141.         move.l               $0108,&dest
  142.         EndM
  143.     ELSE
  144.         IMPORT_CFM_FUNCTION    TopMem
  145.     ENDIF
  146.  
  147. ;
  148. ; pascal OSErr MemError(void)
  149. ;
  150.     IF ¬ GENERATINGCFM THEN
  151.         Macro
  152.         _MemError         &dest=(sp)
  153.         move.w               $0220,&dest
  154.         EndM
  155.     ELSE
  156.         IMPORT_CFM_FUNCTION    MemError
  157.     ENDIF
  158.  
  159. ;
  160. ; pascal THz GetZone(void)
  161. ;
  162.     IF ¬ GENERATINGCFM THEN
  163.         ; returns: 
  164.         ;     THz               <= A0
  165.         _GetZone:    OPWORD    $A11A
  166.     ELSE
  167.         IMPORT_CFM_FUNCTION    GetZone
  168.     ENDIF
  169.  
  170. ;
  171. ; pascal Handle NewHandle(Size byteCount)
  172. ;
  173.     IF ¬ GENERATINGCFM THEN
  174.         ; parameters: 
  175.         ;     byteCount         => D0
  176.         ; returns: 
  177.         ;     Handle            <= A0
  178.         _NewHandle:    OPWORD    $A122
  179.     ELSE
  180.         IMPORT_CFM_FUNCTION    NewHandle
  181.     ENDIF
  182.  
  183. ;
  184. ; pascal Handle NewHandleSys(Size byteCount)
  185. ;
  186.     IF ¬ GENERATINGCFM THEN
  187.         ; parameters: 
  188.         ;     byteCount         => D0
  189.         ; returns: 
  190.         ;     Handle            <= A0
  191.         _NewHandleSys:    OPWORD    $A522
  192.     ELSE
  193.         IMPORT_CFM_FUNCTION    NewHandleSys
  194.     ENDIF
  195.  
  196. ;
  197. ; pascal Handle NewHandleClear(Size byteCount)
  198. ;
  199.     IF ¬ GENERATINGCFM THEN
  200.         ; parameters: 
  201.         ;     byteCount         => D0
  202.         ; returns: 
  203.         ;     Handle            <= A0
  204.         _NewHandleClear:    OPWORD    $A322
  205.     ELSE
  206.         IMPORT_CFM_FUNCTION    NewHandleClear
  207.     ENDIF
  208.  
  209. ;
  210. ; pascal Handle NewHandleSysClear(Size byteCount)
  211. ;
  212.     IF ¬ GENERATINGCFM THEN
  213.         ; parameters: 
  214.         ;     byteCount         => D0
  215.         ; returns: 
  216.         ;     Handle            <= A0
  217.         _NewHandleSysClear:    OPWORD    $A722
  218.     ELSE
  219.         IMPORT_CFM_FUNCTION    NewHandleSysClear
  220.     ENDIF
  221.  
  222. ;
  223. ; pascal THz HandleZone(Handle h)
  224. ;
  225.     IF ¬ GENERATINGCFM THEN
  226.         ; parameters: 
  227.         ;     h                 => A0
  228.         ; returns: 
  229.         ;     THz               <= A0
  230.         _HandleZone:    OPWORD    $A126
  231.     ELSE
  232.         IMPORT_CFM_FUNCTION    HandleZone
  233.     ENDIF
  234.  
  235. ;
  236. ; pascal Handle RecoverHandle(Ptr p)
  237. ;
  238.     IF ¬ GENERATINGCFM THEN
  239.         ; parameters: 
  240.         ;     p                 => A0
  241.         ; returns: 
  242.         ;     Handle            <= A0
  243.         _RecoverHandle:    OPWORD    $A128
  244.     ELSE
  245.         IMPORT_CFM_FUNCTION    RecoverHandle
  246.     ENDIF
  247.  
  248. ;
  249. ; pascal Handle RecoverHandleSys(Ptr p)
  250. ;
  251.     IF ¬ GENERATINGCFM THEN
  252.         ; parameters: 
  253.         ;     p                 => A0
  254.         ; returns: 
  255.         ;     Handle            <= A0
  256.         _RecoverHandleSys:    OPWORD    $A528
  257.     ELSE
  258.         IMPORT_CFM_FUNCTION    RecoverHandleSys
  259.     ENDIF
  260.  
  261. ;
  262. ; pascal Ptr NewPtr(Size byteCount)
  263. ;
  264.     IF ¬ GENERATINGCFM THEN
  265.         ; parameters: 
  266.         ;     byteCount         => D0
  267.         ; returns: 
  268.         ;     Ptr               <= A0
  269.         _NewPtr:    OPWORD    $A11E
  270.     ELSE
  271.         IMPORT_CFM_FUNCTION    NewPtr
  272.     ENDIF
  273.  
  274. ;
  275. ; pascal Ptr NewPtrSys(Size byteCount)
  276. ;
  277.     IF ¬ GENERATINGCFM THEN
  278.         ; parameters: 
  279.         ;     byteCount         => D0
  280.         ; returns: 
  281.         ;     Ptr               <= A0
  282.         _NewPtrSys:    OPWORD    $A51E
  283.     ELSE
  284.         IMPORT_CFM_FUNCTION    NewPtrSys
  285.     ENDIF
  286.  
  287. ;
  288. ; pascal Ptr NewPtrClear(Size byteCount)
  289. ;
  290.     IF ¬ GENERATINGCFM THEN
  291.         ; parameters: 
  292.         ;     byteCount         => D0
  293.         ; returns: 
  294.         ;     Ptr               <= A0
  295.         _NewPtrClear:    OPWORD    $A31E
  296.     ELSE
  297.         IMPORT_CFM_FUNCTION    NewPtrClear
  298.     ENDIF
  299.  
  300. ;
  301. ; pascal Ptr NewPtrSysClear(Size byteCount)
  302. ;
  303.     IF ¬ GENERATINGCFM THEN
  304.         ; parameters: 
  305.         ;     byteCount         => D0
  306.         ; returns: 
  307.         ;     Ptr               <= A0
  308.         _NewPtrSysClear:    OPWORD    $A71E
  309.     ELSE
  310.         IMPORT_CFM_FUNCTION    NewPtrSysClear
  311.     ENDIF
  312.  
  313. ;
  314. ; pascal THz PtrZone(Ptr p)
  315. ;
  316.     IF ¬ GENERATINGCFM THEN
  317.         ; parameters: 
  318.         ;     p                 => A0
  319.         ; returns: 
  320.         ;     THz               <= A0
  321.         _PtrZone:    OPWORD    $A148
  322.     ELSE
  323.         IMPORT_CFM_FUNCTION    PtrZone
  324.     ENDIF
  325.  
  326. ;
  327. ; pascal long MaxBlock(void)
  328. ;
  329.     IF ¬ GENERATINGCFM THEN
  330.         ; returns: 
  331.         ;     long              <= D0
  332.         _MaxBlock:    OPWORD    $A061
  333.     ELSE
  334.         IMPORT_CFM_FUNCTION    MaxBlock
  335.     ENDIF
  336.  
  337. ;
  338. ; pascal long MaxBlockSys(void)
  339. ;
  340.     IF ¬ GENERATINGCFM THEN
  341.         ; returns: 
  342.         ;     long              <= D0
  343.         _MaxBlockSys:    OPWORD    $A461
  344.     ELSE
  345.         IMPORT_CFM_FUNCTION    MaxBlockSys
  346.     ENDIF
  347.  
  348. ;
  349. ; pascal long StackSpace(void)
  350. ;
  351.     IF ¬ GENERATINGCFM THEN
  352.         ; returns: 
  353.         ;     long              <= D0
  354.         _StackSpace:    OPWORD    $A065
  355.     ELSE
  356.         IMPORT_CFM_FUNCTION    StackSpace
  357.     ENDIF
  358.  
  359. ;
  360. ; pascal Handle NewEmptyHandle(void)
  361. ;
  362.     IF ¬ GENERATINGCFM THEN
  363.         ; returns: 
  364.         ;     Handle            <= A0
  365.         _NewEmptyHandle:    OPWORD    $A166
  366.     ELSE
  367.         IMPORT_CFM_FUNCTION    NewEmptyHandle
  368.     ENDIF
  369.  
  370. ;
  371. ; pascal Handle NewEmptyHandleSys(void)
  372. ;
  373.     IF ¬ GENERATINGCFM THEN
  374.         ; returns: 
  375.         ;     Handle            <= A0
  376.         _NewEmptyHandleSys:    OPWORD    $A566
  377.     ELSE
  378.         IMPORT_CFM_FUNCTION    NewEmptyHandleSys
  379.     ENDIF
  380.  
  381. ;
  382. ; pascal void HLock(Handle h)
  383. ;
  384.     IF ¬ GENERATINGCFM THEN
  385.         ; parameters: 
  386.         ;     h                 => A0
  387.         _HLock:    OPWORD    $A029
  388.     ELSE
  389.         IMPORT_CFM_FUNCTION    HLock
  390.     ENDIF
  391.  
  392. ;
  393. ; pascal void HUnlock(Handle h)
  394. ;
  395.     IF ¬ GENERATINGCFM THEN
  396.         ; parameters: 
  397.         ;     h                 => A0
  398.         _HUnlock:    OPWORD    $A02A
  399.     ELSE
  400.         IMPORT_CFM_FUNCTION    HUnlock
  401.     ENDIF
  402.  
  403. ;
  404. ; pascal void HPurge(Handle h)
  405. ;
  406.     IF ¬ GENERATINGCFM THEN
  407.         ; parameters: 
  408.         ;     h                 => A0
  409.         _HPurge:    OPWORD    $A049
  410.     ELSE
  411.         IMPORT_CFM_FUNCTION    HPurge
  412.     ENDIF
  413.  
  414. ;
  415. ; pascal void HNoPurge(Handle h)
  416. ;
  417.     IF ¬ GENERATINGCFM THEN
  418.         ; parameters: 
  419.         ;     h                 => A0
  420.         _HNoPurge:    OPWORD    $A04A
  421.     ELSE
  422.         IMPORT_CFM_FUNCTION    HNoPurge
  423.     ENDIF
  424.  
  425. ;
  426. ; pascal void HLockHi(Handle h)
  427. ;
  428.     IF ¬ GENERATINGCFM THEN
  429.         ; parameters: 
  430.         ;     h                 => A0
  431.         Macro
  432.         _HLockHi
  433.             dc.w     $A064
  434.             dc.w     $A029
  435.         EndM
  436.     ELSE
  437.         IMPORT_CFM_FUNCTION    HLockHi
  438.     ENDIF
  439.  
  440. ;
  441. ; pascal Handle TempNewHandle(Size logicalSize, OSErr *resultCode)
  442. ;
  443.     IF ¬ GENERATINGCFM THEN
  444.         Macro
  445.         _TempNewHandle
  446.             move.w    #$001D,-(sp)
  447.             dc.w     $A88F
  448.         EndM
  449.     ELSE
  450.         IMPORT_CFM_FUNCTION    TempNewHandle
  451.     ENDIF
  452.  
  453. ;
  454. ; pascal Size TempMaxMem(Size *grow)
  455. ;
  456.     IF ¬ GENERATINGCFM THEN
  457.         Macro
  458.         _TempMaxMem
  459.             move.w    #$0015,-(sp)
  460.             dc.w     $A88F
  461.         EndM
  462.     ELSE
  463.         IMPORT_CFM_FUNCTION    TempMaxMem
  464.     ENDIF
  465.  
  466. ;
  467. ; pascal long TempFreeMem(void)
  468. ;
  469.     IF ¬ GENERATINGCFM THEN
  470.         Macro
  471.         _TempFreeMem
  472.             move.w    #$0018,-(sp)
  473.             dc.w     $A88F
  474.         EndM
  475.     ELSE
  476.         IMPORT_CFM_FUNCTION    TempFreeMem
  477.     ENDIF
  478.  
  479. ;  Temporary Memory routines renamed, but obsolete, in System 7.0 and later.  
  480. ;
  481. ; pascal void TempHLock(Handle h, OSErr *resultCode)
  482. ;
  483.     IF ¬ GENERATINGCFM THEN
  484.         Macro
  485.         _TempHLock
  486.             move.w    #$001E,-(sp)
  487.             dc.w     $A88F
  488.         EndM
  489.     ELSE
  490.         IMPORT_CFM_FUNCTION    TempHLock
  491.     ENDIF
  492.  
  493. ;
  494. ; pascal void TempHUnlock(Handle h, OSErr *resultCode)
  495. ;
  496.     IF ¬ GENERATINGCFM THEN
  497.         Macro
  498.         _TempHUnlock
  499.             move.w    #$001F,-(sp)
  500.             dc.w     $A88F
  501.         EndM
  502.     ELSE
  503.         IMPORT_CFM_FUNCTION    TempHUnlock
  504.     ENDIF
  505.  
  506. ;
  507. ; pascal void TempDisposeHandle(Handle h, OSErr *resultCode)
  508. ;
  509.     IF ¬ GENERATINGCFM THEN
  510.         Macro
  511.         _TempDisposeHandle
  512.             move.w    #$0020,-(sp)
  513.             dc.w     $A88F
  514.         EndM
  515.     ELSE
  516.         IMPORT_CFM_FUNCTION    TempDisposeHandle
  517.     ENDIF
  518.  
  519. ;
  520. ; pascal Ptr TempTopMem(void)
  521. ;
  522.     IF ¬ GENERATINGCFM THEN
  523.         Macro
  524.         _TempTopMem
  525.             move.w    #$0016,-(sp)
  526.             dc.w     $A88F
  527.         EndM
  528.     ELSE
  529.         IMPORT_CFM_FUNCTION    TempTopMem
  530.     ENDIF
  531.  
  532. ;
  533. ; pascal void InitApplZone(void)
  534. ;
  535.     IF ¬ GENERATINGCFM THEN
  536.         _InitApplZone:    OPWORD    $A02C
  537.     ELSE
  538.         IMPORT_CFM_FUNCTION    InitApplZone
  539.     ENDIF
  540.  
  541. ;
  542. ; pascal void InitZone(GrowZoneUPP pgrowZone, short cmoreMasters, void *limitPtr, void *startPtr)
  543. ;
  544.     IF ¬ GENERATINGCFM THEN
  545.         _InitZone:    OPWORD    $A019
  546.     ELSE
  547.         IMPORT_CFM_FUNCTION    InitZone
  548.     ENDIF
  549.  
  550. ;
  551. ; pascal void SetZone(THz hz)
  552. ;
  553.     IF ¬ GENERATINGCFM THEN
  554.         ; parameters: 
  555.         ;     hz                => A0
  556.         _SetZone:    OPWORD    $A01B
  557.     ELSE
  558.         IMPORT_CFM_FUNCTION    SetZone
  559.     ENDIF
  560.  
  561. ;
  562. ; pascal Size CompactMem(Size cbNeeded)
  563. ;
  564.     IF ¬ GENERATINGCFM THEN
  565.         ; parameters: 
  566.         ;     cbNeeded          => D0
  567.         ; returns: 
  568.         ;     Size              <= D0
  569.         _CompactMem:    OPWORD    $A04C
  570.     ELSE
  571.         IMPORT_CFM_FUNCTION    CompactMem
  572.     ENDIF
  573.  
  574. ;
  575. ; pascal Size CompactMemSys(Size cbNeeded)
  576. ;
  577.     IF ¬ GENERATINGCFM THEN
  578.         ; parameters: 
  579.         ;     cbNeeded          => D0
  580.         ; returns: 
  581.         ;     Size              <= D0
  582.         _CompactMemSys:    OPWORD    $A44C
  583.     ELSE
  584.         IMPORT_CFM_FUNCTION    CompactMemSys
  585.     ENDIF
  586.  
  587. ;
  588. ; pascal void PurgeMem(Size cbNeeded)
  589. ;
  590.     IF ¬ GENERATINGCFM THEN
  591.         ; parameters: 
  592.         ;     cbNeeded          => D0
  593.         _PurgeMem:    OPWORD    $A04D
  594.     ELSE
  595.         IMPORT_CFM_FUNCTION    PurgeMem
  596.     ENDIF
  597.  
  598. ;
  599. ; pascal void PurgeMemSys(Size cbNeeded)
  600. ;
  601.     IF ¬ GENERATINGCFM THEN
  602.         ; parameters: 
  603.         ;     cbNeeded          => D0
  604.         _PurgeMemSys:    OPWORD    $A44D
  605.     ELSE
  606.         IMPORT_CFM_FUNCTION    PurgeMemSys
  607.     ENDIF
  608.  
  609. ;
  610. ; pascal long FreeMem(void)
  611. ;
  612.     IF ¬ GENERATINGCFM THEN
  613.         ; returns: 
  614.         ;     long              <= D0
  615.         _FreeMem:    OPWORD    $A01C
  616.     ELSE
  617.         IMPORT_CFM_FUNCTION    FreeMem
  618.     ENDIF
  619.  
  620. ;
  621. ; pascal long FreeMemSys(void)
  622. ;
  623.     IF ¬ GENERATINGCFM THEN
  624.         ; returns: 
  625.         ;     long              <= D0
  626.         _FreeMemSys:    OPWORD    $A41C
  627.     ELSE
  628.         IMPORT_CFM_FUNCTION    FreeMemSys
  629.     ENDIF
  630.  
  631. ;
  632. ; pascal void ReserveMem(Size cbNeeded)
  633. ;
  634.     IF ¬ GENERATINGCFM THEN
  635.         ; parameters: 
  636.         ;     cbNeeded          => D0
  637.         _ReserveMem:    OPWORD    $A040
  638.     ELSE
  639.         IMPORT_CFM_FUNCTION    ReserveMem
  640.     ENDIF
  641.  
  642. ;
  643. ; pascal void ReserveMemSys(Size cbNeeded)
  644. ;
  645.     IF ¬ GENERATINGCFM THEN
  646.         ; parameters: 
  647.         ;     cbNeeded          => D0
  648.         _ReserveMemSys:    OPWORD    $A440
  649.     ELSE
  650.         IMPORT_CFM_FUNCTION    ReserveMemSys
  651.     ENDIF
  652.  
  653. ;
  654. ; pascal Size MaxMem(Size *grow)
  655. ;
  656.     IF ¬ GENERATINGCFM THEN
  657.         _MaxMem:    OPWORD    $A11D
  658.     ELSE
  659.         IMPORT_CFM_FUNCTION    MaxMem
  660.     ENDIF
  661.  
  662. ;
  663. ; pascal Size MaxMemSys(Size *grow)
  664. ;
  665.     IF ¬ GENERATINGCFM THEN
  666.         _MaxMemSys:    OPWORD    $A51D
  667.     ELSE
  668.         IMPORT_CFM_FUNCTION    MaxMemSys
  669.     ENDIF
  670.  
  671. ;
  672. ; pascal void SetGrowZone(GrowZoneUPP growZone)
  673. ;
  674.     IF ¬ GENERATINGCFM THEN
  675.         ; parameters: 
  676.         ;     growZone          => A0
  677.         _SetGrowZone:    OPWORD    $A04B
  678.     ELSE
  679.         IMPORT_CFM_FUNCTION    SetGrowZone
  680.     ENDIF
  681.  
  682. ;
  683. ; pascal void SetApplLimit(void *zoneLimit)
  684. ;
  685.     IF ¬ GENERATINGCFM THEN
  686.         ; parameters: 
  687.         ;     zoneLimit         => A0
  688.         _SetApplLimit:    OPWORD    $A02D
  689.     ELSE
  690.         IMPORT_CFM_FUNCTION    SetApplLimit
  691.     ENDIF
  692.  
  693. ;
  694. ; pascal void MoveHHi(Handle h)
  695. ;
  696.     IF ¬ GENERATINGCFM THEN
  697.         ; parameters: 
  698.         ;     h                 => A0
  699.         _MoveHHi:    OPWORD    $A064
  700.     ELSE
  701.         IMPORT_CFM_FUNCTION    MoveHHi
  702.     ENDIF
  703.  
  704. ;
  705. ; pascal void DisposePtr(Ptr p)
  706. ;
  707.     IF ¬ GENERATINGCFM THEN
  708.         ; parameters: 
  709.         ;     p                 => A0
  710.         _DisposePtr:    OPWORD    $A01F
  711.     ELSE
  712.         IMPORT_CFM_FUNCTION    DisposePtr
  713.     ENDIF
  714.  
  715. ;
  716. ; pascal Size GetPtrSize(Ptr p)
  717. ;
  718.     IF ¬ GENERATINGCFM THEN
  719.         _GetPtrSize:    OPWORD    $A021
  720.     ELSE
  721.         IMPORT_CFM_FUNCTION    GetPtrSize
  722.     ENDIF
  723.  
  724. ;
  725. ; pascal void SetPtrSize(Ptr p, Size newSize)
  726. ;
  727.     IF ¬ GENERATINGCFM THEN
  728.         ; parameters: 
  729.         ;     p                 => A0
  730.         ;     newSize           => D0
  731.         _SetPtrSize:    OPWORD    $A020
  732.     ELSE
  733.         IMPORT_CFM_FUNCTION    SetPtrSize
  734.     ENDIF
  735.  
  736. ;
  737. ; pascal void DisposeHandle(Handle h)
  738. ;
  739.     IF ¬ GENERATINGCFM THEN
  740.         ; parameters: 
  741.         ;     h                 => A0
  742.         _DisposeHandle:    OPWORD    $A023
  743.     ELSE
  744.         IMPORT_CFM_FUNCTION    DisposeHandle
  745.     ENDIF
  746.  
  747. ;
  748. ; pascal void SetHandleSize(Handle h, Size newSize)
  749. ;
  750.     IF ¬ GENERATINGCFM THEN
  751.         ; parameters: 
  752.         ;     h                 => A0
  753.         ;     newSize           => D0
  754.         _SetHandleSize:    OPWORD    $A024
  755.     ELSE
  756.         IMPORT_CFM_FUNCTION    SetHandleSize
  757.     ENDIF
  758.  
  759. ;
  760. ; pascal Size GetHandleSize(Handle h)
  761. ;
  762.     IF ¬ GENERATINGCFM THEN
  763.         _GetHandleSize:    OPWORD    $A025
  764.     ELSE
  765.         IMPORT_CFM_FUNCTION    GetHandleSize
  766.     ENDIF
  767.  
  768. ;
  769. ; pascal Size InlineGetHandleSize(Handle h)
  770. ;
  771.     IF ¬ GENERATINGCFM THEN
  772.         ; parameters: 
  773.         ;     h                 => A0
  774.         ; returns: 
  775.         ;     Size              <= D0
  776.         _InlineGetHandleSize:    OPWORD    $A025
  777.     ELSE
  778.         IMPORT_CFM_FUNCTION    InlineGetHandleSize
  779.     ENDIF
  780.  
  781. ;
  782. ; pascal void ReallocateHandle(Handle h, Size byteCount)
  783. ;
  784.     IF ¬ GENERATINGCFM THEN
  785.         ; parameters: 
  786.         ;     h                 => A0
  787.         ;     byteCount         => D0
  788.         _ReallocateHandle:    OPWORD    $A027
  789.     ELSE
  790.         IMPORT_CFM_FUNCTION    ReallocateHandle
  791.     ENDIF
  792.  
  793. ;
  794. ; pascal void EmptyHandle(Handle h)
  795. ;
  796.     IF ¬ GENERATINGCFM THEN
  797.         ; parameters: 
  798.         ;     h                 => A0
  799.         _EmptyHandle:    OPWORD    $A02B
  800.     ELSE
  801.         IMPORT_CFM_FUNCTION    EmptyHandle
  802.     ENDIF
  803.  
  804. ;
  805. ; pascal void HSetRBit(Handle h)
  806. ;
  807.     IF ¬ GENERATINGCFM THEN
  808.         ; parameters: 
  809.         ;     h                 => A0
  810.         _HSetRBit:    OPWORD    $A067
  811.     ELSE
  812.         IMPORT_CFM_FUNCTION    HSetRBit
  813.     ENDIF
  814.  
  815. ;
  816. ; pascal void HClrRBit(Handle h)
  817. ;
  818.     IF ¬ GENERATINGCFM THEN
  819.         ; parameters: 
  820.         ;     h                 => A0
  821.         _HClrRBit:    OPWORD    $A068
  822.     ELSE
  823.         IMPORT_CFM_FUNCTION    HClrRBit
  824.     ENDIF
  825.  
  826. ;
  827. ; pascal void MoreMasters(void)
  828. ;
  829.     IF ¬ GENERATINGCFM THEN
  830.         _MoreMasters:    OPWORD    $A036
  831.     ELSE
  832.         IMPORT_CFM_FUNCTION    MoreMasters
  833.     ENDIF
  834.  
  835. ;
  836. ; pascal void BlockMove(const void *srcPtr, void *destPtr, Size byteCount)
  837. ;
  838.     IF ¬ GENERATINGCFM THEN
  839.         ; parameters: 
  840.         ;     srcPtr            => A0
  841.         ;     destPtr           => A1
  842.         ;     byteCount         => D0
  843.         _BlockMove:    OPWORD    $A02E
  844.     ELSE
  845.         IMPORT_CFM_FUNCTION    BlockMove
  846.     ENDIF
  847.  
  848. ;
  849. ; pascal void BlockMoveData(const void *srcPtr, void *destPtr, Size byteCount)
  850. ;
  851.     IF ¬ GENERATINGCFM THEN
  852.         ; parameters: 
  853.         ;     srcPtr            => A0
  854.         ;     destPtr           => A1
  855.         ;     byteCount         => D0
  856.         _BlockMoveData:    OPWORD    $A22E
  857.     ELSE
  858.         IMPORT_CFM_FUNCTION    BlockMoveData
  859.     ENDIF
  860.  
  861. ;
  862. ; pascal void PurgeSpace(long *total, long *contig)
  863. ;
  864.     IF ¬ GENERATINGCFM THEN
  865.         _PurgeSpace:    OPWORD    $A162
  866.     ELSE
  867.         IMPORT_CFM_FUNCTION    PurgeSpace
  868.     ENDIF
  869.  
  870. ;
  871. ; pascal SInt8 HGetState(Handle h)
  872. ;
  873.     IF ¬ GENERATINGCFM THEN
  874.         ; parameters: 
  875.         ;     h                 => A0
  876.         ; returns: 
  877.         ;     SInt8             <= D0
  878.         _HGetState:    OPWORD    $A069
  879.     ELSE
  880.         IMPORT_CFM_FUNCTION    HGetState
  881.     ENDIF
  882.  
  883. ;
  884. ; pascal void HSetState(Handle h, SInt8 flags)
  885. ;
  886.     IF ¬ GENERATINGCFM THEN
  887.         ; parameters: 
  888.         ;     h                 => A0
  889.         ;     flags             => D0
  890.         _HSetState:    OPWORD    $A06A
  891.     ELSE
  892.         IMPORT_CFM_FUNCTION    HSetState
  893.     ENDIF
  894.  
  895. ;
  896. ; pascal void SetApplBase(void *startPtr)
  897. ;
  898.     IF ¬ GENERATINGCFM THEN
  899.         ; parameters: 
  900.         ;     startPtr          => A0
  901.         _SetApplBase:    OPWORD    $A057
  902.     ELSE
  903.         IMPORT_CFM_FUNCTION    SetApplBase
  904.     ENDIF
  905.  
  906. ;
  907. ; pascal void MaxApplZone(void)
  908. ;
  909.     IF ¬ GENERATINGCFM THEN
  910.         _MaxApplZone:    OPWORD    $A063
  911.     ELSE
  912.         IMPORT_CFM_FUNCTION    MaxApplZone
  913.     ENDIF
  914.  
  915. ;
  916. ; pascal OSErr HoldMemory(void *address, unsigned long count)
  917. ;
  918.     IF ¬ GENERATINGCFM THEN
  919.         ; parameters: 
  920.         ;     address           => A0
  921.         ;     count             => A1
  922.         ; returns: 
  923.         ;     OSErr             <= D0
  924.         Macro
  925.         _HoldMemory
  926.             moveq    #0,d0
  927.             dc.w     $A05C
  928.         EndM
  929.     ELSE
  930.         IMPORT_CFM_FUNCTION    HoldMemory
  931.     ENDIF
  932.  
  933. ;
  934. ; pascal OSErr UnholdMemory(void *address, unsigned long count)
  935. ;
  936.     IF ¬ GENERATINGCFM THEN
  937.         ; parameters: 
  938.         ;     address           => A0
  939.         ;     count             => A1
  940.         ; returns: 
  941.         ;     OSErr             <= D0
  942.         Macro
  943.         _UnholdMemory
  944.             moveq    #1,d0
  945.             dc.w     $A05C
  946.         EndM
  947.     ELSE
  948.         IMPORT_CFM_FUNCTION    UnholdMemory
  949.     ENDIF
  950.  
  951. ;
  952. ; pascal OSErr LockMemory(void *address, unsigned long count)
  953. ;
  954.     IF ¬ GENERATINGCFM THEN
  955.         ; parameters: 
  956.         ;     address           => A0
  957.         ;     count             => A1
  958.         ; returns: 
  959.         ;     OSErr             <= D0
  960.         Macro
  961.         _LockMemory
  962.             moveq    #2,d0
  963.             dc.w     $A05C
  964.         EndM
  965.     ELSE
  966.         IMPORT_CFM_FUNCTION    LockMemory
  967.     ENDIF
  968.  
  969. ;
  970. ; pascal OSErr LockMemoryContiguous(void *address, unsigned long count)
  971. ;
  972.     IF ¬ GENERATINGCFM THEN
  973.         ; parameters: 
  974.         ;     address           => A0
  975.         ;     count             => A1
  976.         ; returns: 
  977.         ;     OSErr             <= D0
  978.         Macro
  979.         _LockMemoryContiguous
  980.             moveq    #4,d0
  981.             dc.w     $A05C
  982.         EndM
  983.     ELSE
  984.         IMPORT_CFM_FUNCTION    LockMemoryContiguous
  985.     ENDIF
  986.  
  987. ;
  988. ; pascal OSErr UnlockMemory(void *address, unsigned long count)
  989. ;
  990.     IF ¬ GENERATINGCFM THEN
  991.         ; parameters: 
  992.         ;     address           => A0
  993.         ;     count             => A1
  994.         ; returns: 
  995.         ;     OSErr             <= D0
  996.         Macro
  997.         _UnlockMemory
  998.             moveq    #3,d0
  999.             dc.w     $A05C
  1000.         EndM
  1001.     ELSE
  1002.         IMPORT_CFM_FUNCTION    UnlockMemory
  1003.     ENDIF
  1004.  
  1005. ;
  1006. ; pascal OSErr GetPhysical(LogicalToPhysicalTable *addresses, unsigned long *physicalEntryCount)
  1007. ;
  1008.     IF ¬ GENERATINGCFM THEN
  1009.         Macro
  1010.         _GetPhysical
  1011.             moveq    #5,d0
  1012.             dc.w     $A05C
  1013.         EndM
  1014.     ELSE
  1015.         IMPORT_CFM_FUNCTION    GetPhysical
  1016.     ENDIF
  1017.  
  1018. ;
  1019. ; pascal OSErr DeferUserFn(UserFnUPP userFunction, void *argument)
  1020. ;
  1021.     IF ¬ GENERATINGCFM THEN
  1022.         ; parameters: 
  1023.         ;     userFunction      => A0
  1024.         ;     argument          => D0
  1025.         ; returns: 
  1026.         ;     OSErr             <= D0
  1027.         _DeferUserFn:    OPWORD    $A08F
  1028.     ELSE
  1029.         IMPORT_CFM_FUNCTION    DeferUserFn
  1030.     ENDIF
  1031.  
  1032. ;
  1033. ; pascal long DebuggerGetMax(void)
  1034. ;
  1035.     IF ¬ GENERATINGCFM THEN
  1036.         ; returns: 
  1037.         ;     long              <= D0
  1038.         Macro
  1039.         _DebuggerGetMax
  1040.             moveq    #0,d0
  1041.             dc.w     $A08D
  1042.         EndM
  1043.     ELSE
  1044.         IMPORT_CFM_FUNCTION    DebuggerGetMax
  1045.     ENDIF
  1046.  
  1047. ;
  1048. ; pascal void DebuggerEnter(void)
  1049. ;
  1050.     IF ¬ GENERATINGCFM THEN
  1051.         Macro
  1052.         _DebuggerEnter
  1053.             moveq    #1,d0
  1054.             dc.w     $A08D
  1055.         EndM
  1056.     ELSE
  1057.         IMPORT_CFM_FUNCTION    DebuggerEnter
  1058.     ENDIF
  1059.  
  1060. ;
  1061. ; pascal void DebuggerExit(void)
  1062. ;
  1063.     IF ¬ GENERATINGCFM THEN
  1064.         Macro
  1065.         _DebuggerExit
  1066.             moveq    #2,d0
  1067.             dc.w     $A08D
  1068.         EndM
  1069.     ELSE
  1070.         IMPORT_CFM_FUNCTION    DebuggerExit
  1071.     ENDIF
  1072.  
  1073. ;
  1074. ; pascal void DebuggerPoll(void)
  1075. ;
  1076.     IF ¬ GENERATINGCFM THEN
  1077.         Macro
  1078.         _DebuggerPoll
  1079.             moveq    #3,d0
  1080.             dc.w     $A08D
  1081.         EndM
  1082.     ELSE
  1083.         IMPORT_CFM_FUNCTION    DebuggerPoll
  1084.     ENDIF
  1085.  
  1086. ;
  1087. ; pascal PageState GetPageState(const void *address)
  1088. ;
  1089.     IF ¬ GENERATINGCFM THEN
  1090.         ; parameters: 
  1091.         ;     address           => A0
  1092.         ; returns: 
  1093.         ;     PageState         <= D0
  1094.         Macro
  1095.         _GetPageState
  1096.             moveq    #4,d0
  1097.             dc.w     $A08D
  1098.         EndM
  1099.     ELSE
  1100.         IMPORT_CFM_FUNCTION    GetPageState
  1101.     ENDIF
  1102.  
  1103. ;
  1104. ; pascal Boolean PageFaultFatal(void)
  1105. ;
  1106.     IF ¬ GENERATINGCFM THEN
  1107.         ; returns: 
  1108.         ;     Boolean           <= D0
  1109.         Macro
  1110.         _PageFaultFatal
  1111.             moveq    #5,d0
  1112.             dc.w     $A08D
  1113.         EndM
  1114.     ELSE
  1115.         IMPORT_CFM_FUNCTION    PageFaultFatal
  1116.     ENDIF
  1117.  
  1118. ;
  1119. ; pascal OSErr DebuggerLockMemory(void *address, unsigned long count)
  1120. ;
  1121.     IF ¬ GENERATINGCFM THEN
  1122.         ; parameters: 
  1123.         ;     address           => A0
  1124.         ;     count             => A1
  1125.         ; returns: 
  1126.         ;     OSErr             <= D0
  1127.         Macro
  1128.         _DebuggerLockMemory
  1129.             moveq    #6,d0
  1130.             dc.w     $A08D
  1131.         EndM
  1132.     ELSE
  1133.         IMPORT_CFM_FUNCTION    DebuggerLockMemory
  1134.     ENDIF
  1135.  
  1136. ;
  1137. ; pascal OSErr DebuggerUnlockMemory(void *address, unsigned long count)
  1138. ;
  1139.     IF ¬ GENERATINGCFM THEN
  1140.         ; parameters: 
  1141.         ;     address           => A0
  1142.         ;     count             => A1
  1143.         ; returns: 
  1144.         ;     OSErr             <= D0
  1145.         Macro
  1146.         _DebuggerUnlockMemory
  1147.             moveq    #7,d0
  1148.             dc.w     $A08D
  1149.         EndM
  1150.     ELSE
  1151.         IMPORT_CFM_FUNCTION    DebuggerUnlockMemory
  1152.     ENDIF
  1153.  
  1154. ;
  1155. ; pascal StatusRegisterContents EnterSupervisorMode(void)
  1156. ;
  1157.     IF ¬ GENERATINGCFM THEN
  1158.         ; returns: 
  1159.         ;     StatusRegisterContents    <= D0
  1160.         Macro
  1161.         _EnterSupervisorMode
  1162.             moveq    #8,d0
  1163.             dc.w     $A08D
  1164.         EndM
  1165.     ELSE
  1166.         IMPORT_CFM_FUNCTION    EnterSupervisorMode
  1167.     ENDIF
  1168.  
  1169. ; StripAddress and Translate24To32 macro to nothing on PowerPC
  1170. ;   StripAddress is implemented as a trap in System 6 or later 
  1171.     IF SystemSixOrLater  THEN
  1172. ;
  1173. ; pascal Ptr StripAddress(void *theAddress)
  1174. ;
  1175.     IF ¬ GENERATINGCFM THEN
  1176.         ; parameters: 
  1177.         ;     theAddress        => D0
  1178.         ; returns: 
  1179.         ;     Ptr               <= D0
  1180.         _StripAddress:    OPWORD    $A055
  1181.     ELSE
  1182.         IMPORT_CFM_FUNCTION    StripAddress
  1183.     ENDIF
  1184.  
  1185.     ELSE
  1186. ;
  1187. ; pascal Ptr StripAddress(void *theAddress)
  1188. ;
  1189.     IF GENERATINGCFM THEN
  1190.         IMPORT_CFM_FUNCTION    StripAddress
  1191.     ENDIF
  1192.  
  1193.     ENDIF
  1194. ;
  1195. ; pascal Ptr Translate24To32(void *addr24)
  1196. ;
  1197.     IF ¬ GENERATINGCFM THEN
  1198.         ; parameters: 
  1199.         ;     addr24            => D0
  1200.         ; returns: 
  1201.         ;     Ptr               <= D0
  1202.         _Translate24To32:    OPWORD    $A091
  1203.     ELSE
  1204.         IMPORT_CFM_FUNCTION    Translate24To32
  1205.     ENDIF
  1206.  
  1207. ;
  1208. ; pascal OSErr HandToHand(Handle *theHndl)
  1209. ;
  1210.     IF ¬ GENERATINGCFM THEN
  1211.         _HandToHand:    OPWORD    $A9E1
  1212.     ELSE
  1213.         IMPORT_CFM_FUNCTION    HandToHand
  1214.     ENDIF
  1215.  
  1216. ;
  1217. ; pascal OSErr PtrToXHand(const void *srcPtr, Handle dstHndl, long size)
  1218. ;
  1219.     IF ¬ GENERATINGCFM THEN
  1220.         ; parameters: 
  1221.         ;     srcPtr            => A0
  1222.         ;     dstHndl           => A1
  1223.         ;     size              => D0
  1224.         ; returns: 
  1225.         ;     OSErr             <= D0
  1226.         _PtrToXHand:    OPWORD    $A9E2
  1227.     ELSE
  1228.         IMPORT_CFM_FUNCTION    PtrToXHand
  1229.     ENDIF
  1230.  
  1231. ;
  1232. ; pascal OSErr PtrToHand(const void *srcPtr, Handle *dstHndl, long size)
  1233. ;
  1234.     IF ¬ GENERATINGCFM THEN
  1235.         _PtrToHand:    OPWORD    $A9E3
  1236.     ELSE
  1237.         IMPORT_CFM_FUNCTION    PtrToHand
  1238.     ENDIF
  1239.  
  1240. ;
  1241. ; pascal OSErr HandAndHand(Handle hand1, Handle hand2)
  1242. ;
  1243.     IF ¬ GENERATINGCFM THEN
  1244.         ; parameters: 
  1245.         ;     hand1             => A0
  1246.         ;     hand2             => A1
  1247.         ; returns: 
  1248.         ;     OSErr             <= D0
  1249.         _HandAndHand:    OPWORD    $A9E4
  1250.     ELSE
  1251.         IMPORT_CFM_FUNCTION    HandAndHand
  1252.     ENDIF
  1253.  
  1254. ;
  1255. ; pascal OSErr PtrAndHand(const void *ptr1, Handle hand2, long size)
  1256. ;
  1257.     IF ¬ GENERATINGCFM THEN
  1258.         ; parameters: 
  1259.         ;     ptr1              => A0
  1260.         ;     hand2             => A1
  1261.         ;     size              => D0
  1262.         ; returns: 
  1263.         ;     OSErr             <= D0
  1264.         _PtrAndHand:    OPWORD    $A9EF
  1265.     ELSE
  1266.         IMPORT_CFM_FUNCTION    PtrAndHand
  1267.     ENDIF
  1268.  
  1269.     IF OLDROUTINENAMES  THEN
  1270.     ENDIF
  1271.     ENDIF ; __MEMORY__
  1272.